.TH std::function::operator() 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::function::operator() \- std::function::operator()

.SH Synopsis
   R operator()( Args... args ) const;  \fI(since C++11)\fP

   Invokes the stored callable function target with the parameters args.

   Effectively does INVOKE<R>(f, std::forward<Args>(args)...), where f is the target
   object of *this.

.SH Parameters

   args - parameters to pass to the stored callable function target

.SH Return value

   None if R is void. Otherwise the return value of the invocation of the stored
   callable object.

.SH Exceptions

   Throws std::bad_function_call if *this does not store a callable function target,
   i.e. !*this == true.

.SH Example

   The following example shows how std::function can be passed to other functions by
   value. Also, it shows how std::function can store lambdas.


// Run this code

 #include <functional>
 #include <iostream>

 void call(std::function<int()> f) // can be passed by value
 {
     std::cout << f() << '\\n';
 }

 int normal_function()
 {
     return 42;
 }

 int main()
 {
     int n = 1;
     std::function<int()> f = [&n](){ return n; };
     call(f);

     n = 2;
     call(f);

     f = normal_function;
     call(f);
 }

.SH Output:

 1
 2
 42

.SH See also

   operator()        invokes the target
   (C++23)           \fI(public member function of std::move_only_function)\fP
   operator()        calls the stored function
                     \fI(public member function of std::reference_wrapper<T>)\fP
   bad_function_call the exception thrown when invoking an empty std::function
   \fI(C++11)\fP           \fI(class)\fP
   invoke            invokes any Callable object with given arguments
   invoke_r          and possibility to specify return type
   \fI(C++17)\fP           (since C++23)
   (C++23)           \fI(function template)\fP
